package com.atguigu.juc.cf;

import org.junit.jupiter.api.Test;

import java.util.concurrent.*;

/**
 * @author yanglin
 * @create 2024-01-03 15:03 星期三
 * description:
 */
public class CompletableFutureApiDemo {


    /**
     * 获取计算结果和触发计算
     */
    @Test
    public void testCompletableFutureApi() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "testCompletableFutureApi";
        });
//        System.out.println(completableFuture.get());
//        System.out.println(completableFuture.get(2L, TimeUnit.SECONDS));    //过时不候
//        System.out.println(completableFuture.join());

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        //立刻获取结果不阻塞  计算完成：返回计算完成的结果   没计算完成：返回设定的valueIfAbsent值
        System.out.println(completableFuture.getNow("hello"));

        //是否打断get()立即返回括号里的值
        System.out.println(completableFuture.complete("completeValue") + "\t" + completableFuture.join());

    }


    /**
     * 对计算结果进行处理
     */
    @Test
    public void testCompletableApi2() throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
//        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
//            try {
//                TimeUnit.SECONDS.sleep(1);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            return 1;
//        },threadPool).thenApply(f -> {     //由于存在依赖关系（当前步错，不走下一步），当前步骤有异常，就叫停
////            int i = 10 / 0;   //模拟异常
//            System.out.println("第二步");
//            return f + 2;
//        }).thenApply(f -> {                 //由于存在依赖关系（当前步错，不走下一步），当前步骤有异常，就叫停
//            System.out.println("第三步");
//            return f + 3;
//        }).whenComplete((v,e) -> {
//            if (e == null){
//                System.out.println("计算结果：" + v);
//            }
//        }).exceptionally(e -> {
//            e.printStackTrace();
//            System.out.println(e.getMessage());
//            return null;
//        });

        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 1;
        },threadPool).handle((f,e) -> {     //当前步骤出现异常，不影响下一步
            int i = 10 / 0;   //模拟异常
            System.out.println("第二步");
            return f + 2;
        }).handle((f,e) -> {                 //当前步骤出现异常，不影响下一步
            System.out.println("第三步");
            return f + 3;
        }).whenComplete((v,e) -> {
            if (e == null){
                System.out.println("计算结果：" + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });

        System.out.println(Thread.currentThread().getName() + "---主线程先去执行其他任务了");
        
        //主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭
        TimeUnit.SECONDS.sleep(3);
    }


    /**
     * 对计算结果进行消费
     */
    @Test
    public void testCompletableFutureApi3(){ 
//        CompletableFuture.supplyAsync(() -> {
//            return 1;
//        }).thenApply(f -> {
//            return f + 2;
//        }).thenApply(f -> {
//            return f + 3;
//        }).thenAccept(r -> {    //接收任务的处理结果，并消费处理，无返回结果
//            System.out.println(r);
//        });

        System.out.println(CompletableFuture.supplyAsync(() -> {
            return "resultA";
        }).thenRun(() -> {

        }).join());

        System.out.println(CompletableFuture.supplyAsync(() -> {
            return "resultA";
        }).thenAccept((r) -> {
            System.out.println(r);
        }).join());

        System.out.println(CompletableFuture.supplyAsync(() -> {
            return "resultA";
        }).thenApply(r -> {
            return r + "resultB";
        }).join());
    }
    
}
